package pe.gob.foncodes.ssa.web.controller;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.DecimalFormat;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Properties;
import javax.faces.bean.ManagedBean;
import javax.faces.context.FacesContext;
import javax.naming.AuthenticationException;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.servlet.http.HttpSession;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import pe.gob.foncodes.ssa.bs.administracion.controller.GenericMaintenanceController;
import pe.gob.foncodes.ssa.bs.common.util.Constante;
import pe.gob.foncodes.ssa.bs.common.util.DateHelper;
import pe.gob.foncodes.ssa.bs.common.util.PasswordHelper;
import pe.gob.foncodes.ssa.bs.common.util.ServiceException;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Usuario;
import pe.gob.foncodes.ssa.bs.common.util.StringHelper;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Accion;
import pe.gob.foncodes.ssa.bs.seguridad.domain.ControlAcceso;
import pe.gob.foncodes.ssa.bs.seguridad.domain.General;
import pe.gob.foncodes.ssa.bs.seguridad.domain.HorarioPerfil;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Modulo;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Opcion;
import pe.gob.foncodes.ssa.bs.seguridad.domain.SeguridadAdicional;
import pe.gob.foncodes.ssa.bs.seguridad.domain.SeguridadAdicionalPK;
import pe.gob.foncodes.ssa.bs.seguridad.domain.UsuarioPerfil;
import pe.gob.foncodes.ssa.bs.seguridad.service.UsuarioService;
import pe.gob.foncodes.ssa.web.util.Utilitarios;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.ldap.InitialLdapContext;
import javax.naming.ldap.LdapContext;
import pe.gob.foncodes.ssa.bs.seguridad.domain.Personal;
import pe.gob.foncodes.ssa.bs.seguridad.domain.UsuarioSegumiento;

@ManagedBean(name = "loginController")
public class LoginController extends GenericMaintenanceController {

    private static final Pattern SUB_ERROR_CODE = Pattern.compile(".*\\s([0-9a-f]{3,4}).*");
    protected static Logger log = Logger.getLogger(LoginController.class);
    private String newPassword;
    private String verifyPassword;
    private Date logDate = DateHelper.getFechaActual();
    private DecimalFormat formatoDecimal = new DecimalFormat("####.#");
    private int intento;
    private UsuarioService usuarioService;
    private boolean BMuestraCaptcha;
    private String STextoCaptcha;
    private boolean BOlvidasteClave;
    private boolean BMuestraBloqueo;
    private boolean registraAcesso;
    private boolean logueado = false;
    private String mensaje;
    //Pregunta Secreta
    private List<General> preguntas = new ArrayList<General>();
    private Map<Long, General> preguntasMapa = new HashMap<Long, General>();
    private String SPreguntaSecreta;
    private String SRespuestaSecreta;
    private String SObsContactoAdmin;
    //Confirmacion de Identidad
    private String SDniIdentidad;
    private Date DFechaIdentidad;
    private boolean BObligaPregunta = false;
    //Pantallas
    private String sTerritorial = "";
    private boolean bContactoAdmin = false;
    List<Usuario> lstUsuarios = new ArrayList<Usuario>();
    Usuario selectedUsuario = new Usuario();
    
    private HashMap<String, List<Accion>> menuBar = new HashMap<String, List<Accion>>();
    private List<String> Opciones = new ArrayList<String>();
    private boolean BMuestraFecNac;
    
    @Override
    public void init() {
        setNewPassword("");
        setVerifyPassword("");
        if (((Usuario) getBean()).getFecCambioClave() == null) {
            ((Usuario) getBean()).setFecCambioClave(Constante.FECHA_INICIO);
        }
        setBean(new Usuario());
        Usuario usuario = new Usuario();
        usuario.setTxtClave("");
        setBeanBusqueda(usuario);
        mensaje = "";
        intento = 0;
        BMuestraBloqueo = false;
        bContactoAdmin = false;
    }
    
    public boolean validatePass() {
        boolean success = true;
        if (getNewPassword() == null) {
            setNewPassword("");
        }
        if (getVerifyPassword() == null) {
            setVerifyPassword("");
        }
        if (getNewPassword().equals("")) {
            success = false;
            setMessageError("Debe ingresar correctamente la Nueva contraseña.");
            return success;
        }
        if (!(getNewPassword().length() > 7)) {
            success = false;
            setMessageError("La Nueva Contraseña no puede ser menor a 8 caracteres");
            return success;
        }
        if (getVerifyPassword().equals("")) {
            success = false;
            setMessageError("Debe ingresar correctamente la confirmación de la contraseña.");
            return success;
        }
        if (!(getVerifyPassword().length() > 7)) {
            success = false;
            setMessageError("El valor de Repita su nueva contraseña no puede ser menor a 8 caracteres");
            return success;
        }
        return success;
    }

    public void changePassword() throws Exception {
        if (validatePass()) {
            Usuario miUsr = ((Usuario) getBeanBusqueda());
            //setBeanBusqueda(new Usuario());
            double tiempoEsperaCambioPass = 0;
            General genTiempoEspera = (General) getService().findGeneralByCode(General.class, Constante.TIEMPO_ESPERA_CAMBIO_PASS_DIAS);
            if(genTiempoEspera != null){
                tiempoEsperaCambioPass = Double.valueOf(genTiempoEspera.getTxtValor());
            }
            int maximoPassAlamcenados = 0;
            General genPassAlamcenados = (General) getService().findGeneralByCode(General.class, Constante.MAXIMOS_PASSWORDS_ALMACENADOS);
            if(genPassAlamcenados != null){
                maximoPassAlamcenados = Integer.valueOf(genPassAlamcenados.getTxtValor());
            }
            int maximoPassGuardados = 0;
            General genPassGuardados = (General) getService().findGeneralByCode(General.class, Constante.MAXIMOS_PASSWORDS_REPETIDOS);
            if(genPassGuardados != null){
                maximoPassGuardados = Integer.valueOf(genPassGuardados.getTxtValor());
            }
            //Verifico Fecha del ultimo cambio de contrasenia
            if (tiempoEsperaCambioPass != 0 && DateHelper.fechasDiferenciaEnDias(logDate, miUsr.getFecCambioClave()) <= tiempoEsperaCambioPass) {
                setMessageError(new Exception("Debe esperar un plazo mnimo de " + formatoDecimal.format(tiempoEsperaCambioPass * 24) + " hora(s) para poder cambiar su contraseña."));
            } else {
                if(!BOlvidasteClave){
                    String claveTempAnterior = getUsuarioService().retornaClaveEncriptada(miUsr.getTxtClave(), miUsr.getCodUsuario().toUpperCase().trim());
                    Usuario userTmp = (Usuario) getService().findById(Usuario.class, miUsr.getId());
                    if (!(StringHelper.miCad(userTmp.getTxtClave(), ",").equals(claveTempAnterior))) {
                        setMessageError(new Exception("Los valores de Contraseña anterior y su contraseña actual son diferentes. Por favor, asegúrese que sean iguales."));
                        return;
                    }
                }
                if (newPassword.equals(verifyPassword)) {
                    String claveSinEncriptar = newPassword;
                    String claveFinal = getUsuarioService().retornaClaveEncriptada(newPassword, miUsr.getCodUsuario());
                    if (PasswordHelper.controlPass(miUsr.getTxtClave(), newPassword, miUsr.getCodUsuario(), claveFinal)) {
                        boolean BValRepetido = false;
                        //Falta validar la cantidad de veces
                        List<UsuarioSegumiento> lstSeguimiento = getService().findByNamedQuery("UsuarioSegumiento.findByNidUsuarioAndTxtClaveRepetida", new Object[]{miUsr.getId(), claveFinal});
                        if(lstSeguimiento != null){
                            if(lstSeguimiento.size() > maximoPassGuardados){
                                BValRepetido = true;
                                setMessageError(new Exception("La contraseña ingresada ha superado el límite de veces permitido ( "+maximoPassGuardados+" ) . Por favor, ingrese otra diferente."));
                            }
                        }
                        if(!BValRepetido){
                            ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
                            log.info("Start of Transaction: 'Change Password' at " + DateHelper.getFechaActual());
                            log.info("User initiating transaction" + miUsr.getCodUsuario());
                            String miPassword = "";
                            newPassword = claveFinal;
                            if (maximoPassAlamcenados == 0) {
                                miUsr.setTxtClave(newPassword);
                            } else {
                                miPassword = newPassword + Constante.SEPARADOR_CONTRASENIA + ((Usuario) getBeanBusqueda()).getTxtClaveEncriptada();
                                miUsr.setTxtClave(PasswordHelper.listaPassword(miPassword, maximoPassAlamcenados));
                            }
                            BObligaPregunta = false;
                            if(miUsr.getFlgCambioClave() != null){
                                if(miUsr.getFlgCambioClave().equals(Constante.ESTADO_ACTIVO)){
                                    BObligaPregunta = true;
                                }
                            }
                            miUsr.setFecCambioClave(DateHelper.getFechaActual());
                            miUsr.setFlgBloqueado(Constante.ESTADO_INACTIVO);
                            miUsr.setFlgCambioClave(Constante.ESTADO_INACTIVO);
                            miUsr.setFlgCaducidadClave(Constante.CLAVE_NO_CADUCADA);

                            String strcomentario = "<span>Se remite la actualizaci&oacute;en de la siguiente informaci&oacute;n: </span><br/><br/>"
                                    + "<span>Nueva Contrase&ntilde;a: " + claveSinEncriptar + "</span><br/><br/>";
                            if (miUsr.getTxtCorreoElectronico1() != null) {
                                strcomentario += "<span>Correo Principal: " + miUsr.getTxtCorreoElectronico1() + "</span><br/>";
                            }
                            if (miUsr.getTxtCorreoElectronico2() != null) {
                                strcomentario += "<span>Correo Alternativo: " + miUsr.getTxtCorreoElectronico2() + "</span><br/>";
                            }
                            strcomentario += "<br/><span>Se solicita verificar los datos, si hubiera alg&uacute;n error comunicar a el &aacute;rea correspondiente.</span><br/>";

                            strcomentario += "<br/><br/><span>Nota:  Este es un mensaje informativo enviado de forma autom&aacute;tica.</span><br/>";
                            strcomentario += "<span>Agradecemos no responder a esta direcci&oacute;n de correo</span><br/>";
                            miUsr.setNIdCtrlAccesoWeb(control.getId());
                            setBean(miUsr);
                            try {
                                RequestContext context = RequestContext.getCurrentInstance();
                                super.beforeUpdate(null);
                                super.doUpdate(null);
                                log.info("End of Transaction: 'Update'");
                                //getService().save(getBean());
                                mensaje = "Su contraseña ha sido cambiada de manera exitosa";
                                context.execute("wCambioClave.hide()");
                                context.execute("wCambioClaveOK.show()");
                                if (miUsr.getTxtCorreoElectronico1() != null) {
                                    enviaMail(miUsr.getTxtCorreoElectronico1(), "2", strcomentario);
                                }
                                if (miUsr.getTxtCorreoElectronico2() != null) {
                                    enviaMail(miUsr.getTxtCorreoElectronico2(), "2", strcomentario);
                                }
                                log.info("End of Transaction: 'Change Password'");
                            } catch (Exception e) {
                                log.error("ERROR en changePassword: "+e.getMessage());
                                setMessageError(e);
                            }
                        }
                    } else {
                        setMessageError(new Exception(PasswordHelper.mensaje));
                    }
                } else {
                    setMessageError(new Exception("Los valores de Nueva contraseña y Repita su nueva contraseña son diferentes. Por favor, asegúrese que sean iguales."));
                }
            }
        }
    }

    public void closeSession(HttpSession session) {
        GregorianCalendar gcal = (GregorianCalendar) GregorianCalendar.getInstance();
        Usuario user = ((Usuario) session.getAttribute("usuarioEnSesion"));
        log.info("Closed Session of " + user.getCodUsuario() + " at " + DateHelper.getFechaActual());
        try {
            ControlAcceso control = ((ControlAcceso) session.getAttribute(Constante.SESSION_ACCESO));
            control.setFecSalida(gcal.getTime());
            getService().save(control);
            logueado = false;
        } catch (Exception ex) {
            log.error("ERROR EN closeSession :" + ex.getMessage());
        }
    }

    public void generaClaveTemporal(){
        Usuario usuario = (Usuario) getBean();
        
    }
    
    public String obtenerDireccionIP(){
        InetAddress direccion = null;
        try {
            direccion = InetAddress.getLocalHost();
        } catch (UnknownHostException ex) {
            log.error("ERROR en obtenerDireccionIP :"+ex);
        }
        if(direccion != null){
            return direccion.getHostAddress();
        }else{
            return "";
        }
    }
    
    public void cancelar() {
        setBeanBusqueda(new Usuario());
        setBMuestraCaptcha(false);
    }

    public void limpiaCambioClave() {
        this.newPassword = "";
        this.verifyPassword = "";
    }

    public void habilitaDesbloqueo(){
        BMuestraBloqueo = false;
        limpiaClaveUsuario();
    }
    
    public void limpiaClaveUsuario() {
        Usuario usuario = (Usuario) getBeanBusqueda();
        usuario.setTxtClave("");
        setBeanBusqueda(usuario);
        limpiaCambioClave();
    }

    public void limpiaCodigoUsuario() {
        Usuario usuario = (Usuario) getBeanBusqueda();
        usuario.setCodUsuario("");
        setBeanBusqueda(usuario);
    }
    
    public void limpiaObsContactoAdmin() {
        SObsContactoAdmin = "";
    }
    
    public String login() throws Exception {
        String redirectTo = "login";
        BMuestraBloqueo = false;
        registraAcesso = false;
        logueado = false;
        Usuario usuario = (Usuario) getBeanBusqueda();
        String claveAntigua = usuario.getTxtClave();
        GregorianCalendar gcal = (GregorianCalendar) GregorianCalendar.getInstance();
        gcal.setTime(new Date());
        Date fechaActual = gcal.getTime();
        if (usuario.getCodUsuario() == null) {
            usuario.setCodUsuario("");
        }
        if (usuario.getTxtClave() == null) {
            usuario.setTxtClave("");
        }
        if (usuario.getCodUsuario().trim().equals("")) {
            Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Por favor ingresa tu codigo de usuario");
            return redirectTo;
        }
        if (usuario.getTxtClave().trim().equals("")) {
            Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Por favor ingresa tu contraseña");
            return redirectTo;
        }
        FacesContext facesContext = FacesContext.getCurrentInstance();
        HttpSession session = (HttpSession) facesContext.getExternalContext().getSession(true);
        if (usuario.getCodUsuario().trim().charAt(0) == Constante.CARACTER_USUARIO_DOMINIO) {
            //Cargando parametros del Sistema para el Login
            Long maximoNroIntentosLogin = Long.valueOf(((General) getService().findGeneralByCode(General.class, "MAXIMO_NRO_INTENTOS_LOGIN")).getTxtValor());
            Long maximoTiempoSinCambioPass = Long.valueOf(((General) getService().findGeneralByCode(General.class, "MAXIMO_TIEMPO_SIN_CAMBIO_PASS")).getTxtValor());

            if (usuario.getCodUsuario() != null) {
                usuario.setCodUsuario(usuario.getCodUsuario().toUpperCase().trim());
                String enc_clave = usuario.getTxtClave();
                //llamar a funcion de clave
                enc_clave = getUsuarioService().retornaClaveEncriptada(enc_clave, usuario.getCodUsuario());
                log.info("Clave Encriptada: " + enc_clave);
                usuario.setTxtClave(enc_clave);
            }
            Usuario user = null;
            user = (Usuario) getService().findByCode(Usuario.class, usuario.getCodUsuario().trim());

            if (user == null) {
                Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario no existe");
                setBeanBusqueda(new Usuario());
            } else {
                user.setTxtClaveEncriptada(user.getTxtClave());
                RequestContext context = RequestContext.getCurrentInstance();
                session.setAttribute(Constante.SESSION_USER, user);
                setBean(user);

                ControlAccesoController controlAccesoController = (ControlAccesoController) getSpringBean("controlAccesoController");
                controlAccesoController.load();
                
                log.info(">>>>>> okas="+controlAccesoController.getIntentosValidos());
                log.info(">>>>>> fail="+controlAccesoController.getIntentosRechazados());
                
                //Obtiene el ultimo ingreso del usuario
                Date ultimo_ingreso = controlAccesoController.getUltimoIngreso();

                Modulo moduloSSA = (Modulo) getService().findById(Modulo.class, Constante.NID_MODULO_SSA);
                ControlAcceso loginLog = new ControlAcceso();
                loginLog.setNidUsuario(user);
                loginLog.setCodZonal(user.getCodZonal());
                loginLog.setTipOperacion(Constante.TIPO_OPERACION_INICIO_SESION);
                loginLog.setTxtSessionid(session.getId());
                loginLog.setNidModulo(moduloSSA);
                loginLog.setIp(obtenerDireccionIP());
                
                if(BMuestraCaptcha){
                    String SVal = "";
                    if(session.getAttribute(Constante.CAPTCHA_KEY)!=null){
                        SVal = session.getAttribute(Constante.CAPTCHA_KEY).toString();
                    }
                    if(!STextoCaptcha.equals(SVal)){
                        usuario.setTxtClave(claveAntigua);
                        setBeanBusqueda(usuario);
                        STextoCaptcha = "";
                        setMessageError(new Exception("Los caracteres no coincideron con la imagen. Vuelva a intentarlo"));
                        return redirectTo;
                    }
                }
                if (StringHelper.miCad(user.getTxtClave(), ",").equals(usuario.getTxtClave())) {

                    if (user.getFlgActivo().equals(Constante.ESTADO_INACTIVO)) {
                        usuario.setTxtClave(claveAntigua);
                        setBeanBusqueda(usuario);
                        Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario no se encuentra activo");
                        return redirectTo;
                    }
                    
                    if (user.getFlgBloqueado().equals(Constante.ESTADO_BLOQUEADO)) {
                        user.setTxtClave(claveAntigua);
                        setBeanBusqueda(user);
                        Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario bloqueado");
                        BMuestraBloqueo = true;
                        return redirectTo;
                    }
                    if (user.getFlgCambioClave().equals(Constante.CAMBIO_DE_CLAVE)) {
                        mensaje = "Contraseña Temporal, debe de cambiarla";
                        context.execute("wCambioClaveTemporal.show()");
                        user.setTxtClave(claveAntigua);
                        setBeanBusqueda(user);
                        BOlvidasteClave = false;
                        return redirectTo;
                    }
                    //Abrir el dialog de
                    if (user.getFlgCaducidadClave().equals(Constante.CLAVE_CADUCADA)) {
                        if(user.getFecCambioClave() != null){
                            if(user.getFecCambioClave().before(gcal.getTime())){
                                mensaje = "La contraseña ha caducado";
                                context.execute("wClaveCaduca.show()");
                                user.setTxtClave(claveAntigua);
                                setBeanBusqueda(user);
                                BOlvidasteClave = false;
                                return redirectTo;
                            }
                        }
                    }
                    List<UsuarioPerfil> usuarioPerfilList = getService().findByNamedQuery("UsuarioPerfil.findByNidUsuarioAndFlgActivo", new Object[]{user.getId(), Constante.ESTADO_ACTIVO});
                    /**
                     * Validación de caducidad del perfil
                     */
                    if (validaCaducidaDelPerfil(usuarioPerfilList, gcal.getTime(), moduloSSA)) {
                        usuario.setTxtClave("");
                        setBeanBusqueda(usuario);
                        Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "El Perfil del Usuario ha caducado, contactese con el administrar del sistema");
                        return redirectTo;
                    }
                    
                    //El Perfil del Usuario ha caducado, contactese con el administrar del sistema
                    if (validaHorarioPerfil(usuarioPerfilList, gcal.getTime())) {
                        usuario.setTxtClave("");
                        setBeanBusqueda(usuario);
                        Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "El usuario no se encuentra dentro del horario de acceso permitido");
                        return redirectTo;
                    }
                    loginLog.setFecRegistro(gcal.getTime());
                    loginLog.setFlgAcceso(Constante.INTENTO_VALIDO);
                    loginLog = (ControlAcceso) getService().save(loginLog);
                    session.setAttribute(Constante.SESSION_ACCESO, loginLog);
                    try {
                        loadMenuUsuario(usuarioPerfilList, user);
                    } catch (ServiceException ex) {
                        log.error("ERROR en login: "+ex);
                    }
                    redirectTo = "home";
                } else {
                    intento++;
                    registraAcesso = true;
                    int minimoNroIntentosLogin=maximoNroIntentosLogin.intValue()-2;
                    int minimoMasUnoNroIntentosLogin=maximoNroIntentosLogin.intValue()-1;
                    if(intento < minimoNroIntentosLogin){
                        Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Su contraseña es incorrecta");
                    }else if (intento < maximoNroIntentosLogin){
                        if(intento == minimoNroIntentosLogin){
                            BMuestraCaptcha = true;
                            setMessageError(new Exception("Tiene "+intento+" intentos fallidos. Recuerde luego del intento "+maximoNroIntentosLogin+", su cuenta se bloqueará"));
                        }
                        if(intento == minimoMasUnoNroIntentosLogin){
                            BMuestraCaptcha = true;
                            setMessageError(new Exception("Tiene "+intento+" intentos fallidos. Recuerde luego del intento "+maximoNroIntentosLogin+", su cuenta se bloqueará"));
                        }
                    }else{
                        //NO se guarda NidControlAccesoWeb porque no se ha logueado
                        BMuestraCaptcha = false;
                        Object object = getBean();
                        Usuario usrBloqueo = (Usuario) getBean();
                        usrBloqueo.setFecBloqueo(fechaActual);
                        usrBloqueo.setFlgBloqueado(Constante.ESTADO_BLOQUEADO);
                        usrBloqueo.setTxtMotivoBloqueo(Constante.MOTIVO_BLOQUEO);
                        setBean(usrBloqueo);
                        super.beforeUpdate(null);
                        super.doUpdate(null);
                        log.info("End of Transaction: 'Update'");
                        //getService().save(usrBloqueo);
                        setBeanBusqueda(usrBloqueo);
                        setBean(object);
                        setMessageError(new Exception("Su cuenta ha sido bloqueada por exceder el número de intentos válidos."));
                        BMuestraBloqueo = true;
                        intento = 0;
                    }
                    setBean(new Usuario());
                    usuario.setTxtClave("");
                    setBeanBusqueda(usuario);
                }
                if (registraAcesso) {
                    loginLog.setFecRegistro(fechaActual);
                    loginLog.setFlgAcceso(Constante.INTENTO_RECHAZADO);
                    getService().save(loginLog);
                }
            }
        } else {
            usuario.setCodUsuario(usuario.getCodUsuario().toUpperCase().trim());
            LdapContext ctx = null;
            Hashtable<String, String> env = new Hashtable<String, String>();
            try { 
                env.put(Context.SECURITY_AUTHENTICATION, "simple");
                if (usuario.getCodUsuario() != null) {
                    env.put(Context.SECURITY_PRINCIPAL, usuario.getCodUsuario().trim() + Constante.CARACTER_USUARIO_DOMINIO + Constante.DOMAIN_CONTROLLER);
                }
                if (usuario.getTxtClave() != null) {
                    env.put(Context.SECURITY_CREDENTIALS, usuario.getTxtClave());
                }
                env.put(Context.INITIAL_CONTEXT_FACTORY, Constante.INITIAL_CONTEXT_FACTORY);
                env.put(Context.PROVIDER_URL, Constante.LDAP_SERVER);
                env.put("java.naming.ldap.attributes.binary", "objectSID");
                ctx = new InitialLdapContext(env, null);
                ctx.reconnect(null);
                
                redirectTo = loginUsuarioDominio(usuario, redirectTo, fechaActual, session);
                session.setAttribute(Constante.SESSION_USER, getBean());
            } catch (AuthenticationException a) {
                log.error("Authentication failed: " + a);
                int subErrorCode = parseSubErrorCode(a.getMessage());
                switch (subErrorCode) {
                    case 1331:
                        setMessageError(new Exception("Usuario Inactivo"));
                        break;
                    case 1793:
                        setMessageError(new Exception("La Contraseña Expiro"));
                        break;
                    case 1907:
                        setMessageError(new Exception("La contraseña debe cambiarla por primera vez"));
                        break;
                   case 1326:
                        setMessageError(new Exception("Verifique su código de usuario y contraseña de red"));
                        break;
                    default:
                        setMessageError(new Exception("Ha ocurrido un error con su cuenta. Comuniquese con el administrador"));
                        log.info("Error "+subErrorCode);
                        break;
                }
                return redirectTo;
            } catch (NamingException e) {
                log.error("Failed to bind to LDAP / get account information: " + e);
            } finally {
                if (ctx != null) {
                    ctx.close();
                }
            }
        }
        return redirectTo;
    }

    public String loginUsuarioDominio(Usuario usuario, String redirectTo, Date fechaActual, HttpSession session) throws Exception {
        Usuario user = null;
        user = (Usuario) getService().findByCode(Usuario.class, usuario.getCodUsuario().trim());
        if (user == null) {
            Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "Usuario no registrado");
            setBeanBusqueda(new Usuario());
        } else {
            user.setTxtClaveEncriptada(user.getTxtClave());
            setBean(user);
            Modulo moduloSSA = (Modulo) getService().findById(Modulo.class, Constante.NID_MODULO_SSA);
            ControlAcceso loginLog = new ControlAcceso();
            loginLog.setNidUsuario(user);
            loginLog.setCodZonal(user.getCodZonal());
            loginLog.setTipOperacion(Constante.TIPO_OPERACION_INICIO_SESION);
            loginLog.setTxtSessionid(session.getId());
            loginLog.setNidModulo(moduloSSA);
            loginLog.setFecRegistro(fechaActual);
            loginLog.setFlgAcceso(Constante.INTENTO_VALIDO);
            loginLog.setIp(obtenerDireccionIP());
            loginLog = (ControlAcceso) getService().save(loginLog);
            session.setAttribute(Constante.SESSION_ACCESO, loginLog);
            
            GregorianCalendar gcal = (GregorianCalendar) GregorianCalendar.getInstance();
            gcal.setTime(new Date());
            List<UsuarioPerfil> usuarioPerfilList = getService().findByNamedQuery("UsuarioPerfil.findByNidUsuarioAndFlgActivo", new Object[]{user.getId(), Constante.ESTADO_ACTIVO});
            /**
             * Validación de caducidad del perfil
             */
            if (validaCaducidaDelPerfil(usuarioPerfilList, gcal.getTime(), moduloSSA)) {
                usuario.setTxtClave("");
                setBeanBusqueda(usuario);
                Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "El Perfil del Usuario ha caducado, contactese con el administrar del sistema");
                return redirectTo;
            }

            if (validaHorarioPerfil(usuarioPerfilList, fechaActual)) {
                Utilitarios.mostrarMensajeError(null, "Error en inicio de sesión", "El usuario no se encuentra dentro del horario de acceso permitido");
                return redirectTo;
            }
            try {
                loadMenuUsuario(usuarioPerfilList, user);
            } catch (ServiceException ex) {
                log.error("ERROR en loginUsuarioDominio: "+ex);
            }
            redirectTo = "home";
        }
        return redirectTo;
    }
    
    public boolean validaCaducidaDelPerfil(List<UsuarioPerfil> usuarioPerfilList, Date fechaActual, Modulo nidModulo){
        boolean bValidaCaducidad = false;
        try {
            for (UsuarioPerfil up : usuarioPerfilList) {
                if(up.getNidPerfil().getNidModulo().getId().equals(nidModulo.getId())){
                    if(up.getFecInicio() != null && up.getFecFin() != null){
                        if (up.getFecInicio().before(fechaActual) && up.getFecFin().before(fechaActual)) {
                            up.setFlgCaduca(Constante.PERFILUSUARIO_CADUCADA);
                            getService().save(up);
                            bValidaCaducidad = true;
                            break;
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("ERROR en validaCaducidaDelPerfil: "+e);
        }
        return bValidaCaducidad;
    }
    
    public boolean validaHorarioPerfil(List<UsuarioPerfil> usuarioPerfilList, Date fechaActual){
        boolean bvalidaHorario = false;
        try {    
            List<HorarioPerfil> horarioPerfil = getUsuarioService().retornaHorarioPorPerfiles(usuarioPerfilList, Constante.ESTADO_ACTIVO);
            if (!horarioPerfil.isEmpty()) {//before = antes
                for (HorarioPerfil hp : horarioPerfil) {
                    if (hp.getFecHoraInicio().before(fechaActual) && hp.getFecHoraFin().after(fechaActual)) {
                        bvalidaHorario = true;
                        break;
                    }
                }
            }
        } catch (ServiceException ex) {
            log.error("ERROR en validaHorarioPerfil: "+ex);
        }
        return bvalidaHorario;
    }
    
    public void loadMenuUsuario(List<UsuarioPerfil> usuarioPerfilList, Usuario user) throws Exception {
        menuBar = new HashMap<String, List<Accion>>();
        List<Opcion> firstLevelNodes = getUsuarioService().getFirstLevelNodes(user.getId(), usuarioPerfilList);
        Opciones = new ArrayList<String>();
        for (Opcion opcion : firstLevelNodes) {
            if (!menuBar.containsKey(opcion.getTxtOpcion())) {
                Opciones.add(opcion.getTxtOpcion());
                menuBar.put(opcion.getTxtOpcion(), new ArrayList<Accion>());
                crearMenu(opcion, menuBar, user.getId(), usuarioPerfilList, user.getCodZonal());
            }
        }
        logueado = true;
    }
    
    int parseSubErrorCode(String message) {
        Matcher m = SUB_ERROR_CODE.matcher(message);
        if (m.matches()) {
            return Integer.parseInt(m.group(1), 16);
        }
        return -1;
    }

    public void crearMenu(Opcion opcionPadre, HashMap<String, List<Accion>> menuBar, Long idUsuario, List<UsuarioPerfil> usuarioPerfilList, String codZonal) throws ServiceException {
        List<Accion> acciones = getUsuarioService().getOtherLevelNodes(opcionPadre.getId(), idUsuario, usuarioPerfilList, codZonal);
        if(acciones != null){
            for (Accion ac : acciones) {
                if (menuBar.containsKey(opcionPadre.getTxtOpcion())) {
                    menuBar.get(opcionPadre.getTxtOpcion()).add(ac);
                    //menuBar.put(op.getTxtOpcion(), new ArrayList<Accion>());
                    crearMenu(ac.getNidOpcion(), menuBar, idUsuario, usuarioPerfilList, codZonal);
                }
            }
        }
    }

    public void validaUsuarioOlvidoClave() throws Exception {
        Usuario usuario = (Usuario) getBeanBusqueda();
        if (usuario.getCodUsuario() == null) {
            setMessageError(new Exception("Por favor ingresa tu codigo de usuario"));
            return;
        }
        if (usuario.getCodUsuario().trim().equals("")) {
            setMessageError(new Exception("Por favor ingresa tu codigo de usuario"));
            return;
        }
        Usuario user = null;
        usuario.setCodUsuario(usuario.getCodUsuario().toUpperCase().trim());
        if (usuario.getCodUsuario().charAt(0) == Constante.CARACTER_USUARIO_DOMINIO) {
            user = (Usuario) getService().findByCode(Usuario.class, usuario.getCodUsuario());
            if (user == null) {
                setMessageError(new Exception("Usuario no existe"));
                setBeanBusqueda(new Usuario());
                return;
            } else {
                if(user.getNidPersonal() != null){
                    List<Personal> lstPersonal = getService().findByNamedQuery("Personal.findByNidPersonal", new Object[]{user.getNidPersonal()});
                    if(!lstPersonal.isEmpty()){
                        user.setPersonal(lstPersonal.get(0));
                        if(user.getPersonal().getFecNacimiento()!=null){
                            BMuestraFecNac = true;
                        }else{
                            BMuestraFecNac = false;
                        }
                    }else{
                        BMuestraFecNac = false;
                        user.setPersonal(null);
                    }
                }else{
                    BMuestraFecNac = false;
                    user.setPersonal(null);
                }
                user.setTxtClaveEncriptada(user.getTxtClave());
                RequestContext context = RequestContext.getCurrentInstance();
                List<SeguridadAdicional> lista = getService().findByNamedQuery("SeguridadAdicional.findByNIdUsuarioAndEstado", new Object[]{user.getId(), Constante.ESTADO_ACTIVO});
                user.setSeguridadAdicionalList(lista);
                setBeanBusqueda(user);
                if (lista.isEmpty()) {
                    SPreguntaSecreta = "";
                } else {
                    SPreguntaSecreta = lista.get(0).getGeneral().getTxtParametro();
                }
                context.execute("wOlvidoClave.hide()");
                context.execute("wConfirmaIdentidad.show()");
                context.execute("hideEnlace()");
                BOlvidasteClave = false;
                SRespuestaSecreta = "";
                SDniIdentidad = "";
                DFechaIdentidad = Constante.FECHA_ACTUAL;
            }
        } else {
            setMessageError(new Exception("Usuario sin privilegios para esta acción. Comuníquese con el administrador"));
            return;
        }
    }

    public void validaConfirmacionIdentidad() {
        RequestContext context = RequestContext.getCurrentInstance();
        Usuario usuario = ((Usuario) getBeanBusqueda());
        //validacion de fecha de nacimiento
        if(usuario.getNidPersonal() != null && BMuestraFecNac){
            if(usuario.getPersonal() != null){
                if(usuario.getPersonal().getFecNacimiento() != null){
                    if(!getDFechaIdentidad().equals(usuario.getPersonal().getFecNacimiento())){
                        setMessageError(new Exception("La Fecha de Nacimiento ingresada es diferente a la del usuario"));
                        context.execute("hideEnlace()");
                        return;
                    }
                }
            }
        }
        if (getSDniIdentidad() == null) {
            setSDniIdentidad("");
        }
        if (getSDniIdentidad().trim().equals("")) {
            setMessageError(new Exception("Ingrese el DNI"));
            context.execute("hideEnlace()");
            return;
        }
        if (!getSDniIdentidad().equals(usuario.getCodDni())) {
            setMessageError(new Exception("El DNI ingresado es diferente al del usuario"));
            context.execute("hideEnlace()");
            return;
        }
        if (SRespuestaSecreta == null) {
            SRespuestaSecreta = "";
        }
        if (SRespuestaSecreta.trim().equals("")) {
            setMessageError(new Exception("Ingrese la Respuesta a la Pregunta Secreta"));
            context.execute("hideEnlace()");
            return;
        }
        boolean bRespuestaValida = false;
        for (SeguridadAdicional sa : usuario.getSeguridadAdicionalList()) {
            if (sa.getTxtRespuesta().trim().equals(SRespuestaSecreta.toUpperCase().trim())) {
                bRespuestaValida = true;
                break;
            }
        }
        if (bRespuestaValida) {
            limpiaCambioClave();
            BOlvidasteClave = true;
            context.execute("wConfirmaIdentidad.hide()");
            context.execute("wCambioClave.show()");
        } else {
            BOlvidasteClave = false;
            setMessageError(new Exception("La Respuesta a la Pregunta Secreta no es la correcta"));
            context.execute("verificaEnlace()");
        }
    }

    public void loadPreguntasSecretas() {
        SPreguntaSecreta = "-1";
        SRespuestaSecreta = "";
        try {
            preguntasMapa = new HashMap<Long, General>();
            preguntas = getService().findByNamedQuery("General.findByTxtDominioEstado", new Object[]{Constante.DOMINIO_PREGUNTA_SECRETA, Constante.ESTADO_ACTIVO});
            for (General general : preguntas) {
                preguntasMapa.put(general.getId(), general);
            }
        } catch (ServiceException e) {
            log.error("ERROR EN loadPreguntasSecretas: " + e);
        }
    }

    public void guardarAuditoriaSeguridadAdicional(SeguridadAdicional seguridadAdicional, String tipoOperacion){
        try {
            setBean(seguridadAdicional);
            if(tipoOperacion.equals(Constante.TIPO_OPERACION_INSERTAR)){
                super.beforeSave(null);
                super.doSave(null);
                log.info("End of Transaction: 'Save'");
            }else if(tipoOperacion.equals(Constante.TIPO_OPERACION_MODIFICAR)){
                super.beforeUpdate(null);
                super.doUpdate(null);
                log.info("End of Transaction: 'Update'");
            }else{
                super.beforeDelete(null);
                super.doDelete(null);
                log.info("End of Transaction: 'Delete'");
            }
        } catch (Exception e) {
            log.error("ERROR EN guardarAuditoriaSeguridadAdicional:"+e.getMessage());
        }
    }
    
    public void actualizaPreguntaSecreta() {
        if (SPreguntaSecreta.equals("-1")) {
            setMessageError(new Exception("Seleccione la pregunta"));
            return;
        }
        if (SRespuestaSecreta == null) {
            SRespuestaSecreta = "";
        }
        if (SRespuestaSecreta.trim().equals("")) {
            setMessageError(new Exception("Ingrese la respuesta"));
            return;
        }
        SRespuestaSecreta = SRespuestaSecreta.toUpperCase();
        
        Object bean = getBean();
        
        Usuario miUsr = ((Usuario) getBean());
        List<SeguridadAdicional> lista = new ArrayList<SeguridadAdicional>();
        try {
            lista = getService().findByNamedQuery("SeguridadAdicional.findByNIdUsuarioAndEstado", new Object[]{miUsr.getId(), Constante.ESTADO_ACTIVO});
        } catch (ServiceException e) {
            log.error("ERROR EN actualizaPreguntaSecreta: " + e);
        }
        ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
        for (SeguridadAdicional sa : lista) {
            sa.setFlgActivo(Constante.ESTADO_INACTIVO);
            sa.setNIdCtrlAccesoWeb(control.getId());
            try {
                guardarAuditoriaSeguridadAdicional(sa, Constante.TIPO_OPERACION_ELIMINAR);
                //getService().save(sa);
            } catch (Exception ex) {
                log.error("ERROR EN actualizaPreguntaSecreta: " + ex);
            }
        }
        //Si no tiene registrada una pregunta activa, se ingresa
        SeguridadAdicional seguridadAdicional = new SeguridadAdicional();
        seguridadAdicional.setFecRegistro(Constante.FECHA_ACTUAL);
        seguridadAdicional.setFlgActivo(Constante.ESTADO_ACTIVO);
        seguridadAdicional.setGeneral(preguntasMapa.get(new Long(SPreguntaSecreta)));
        seguridadAdicional.setTxtRespuesta(SRespuestaSecreta.trim());
        seguridadAdicional.setSeguridadAdicionalPK(new SeguridadAdicionalPK(miUsr.getId(), new Long(SPreguntaSecreta)));
        seguridadAdicional.setUsuario(miUsr);
        seguridadAdicional.setNIdCtrlAccesoWeb(control.getId());
        try {
            guardarAuditoriaSeguridadAdicional(seguridadAdicional, Constante.TIPO_OPERACION_INSERTAR);
            //getService().save(seguridadAdicional);
        } catch (Exception ex) {
            log.error("ERROR EN actualizaPreguntaSecreta: " + ex);
        }
        String strcomentario = "<span>Se remite la actualizaci&oacute;n de la siguiente informaci&oacute;n: </span><br/><br/>"
                + "<span>Pregunta Secreta: " + preguntasMapa.get(new Long(SPreguntaSecreta)).getTxtParametro()+"</span><br/>"
                + "<span>Respuesta Secreta: " + SRespuestaSecreta.trim()+"</span><br/><br/> ";
        if (miUsr.getTxtCorreoElectronico1() != null) {
            strcomentario += "<span>Correo Principal: " + miUsr.getTxtCorreoElectronico1()+"</span><br/>";
        }
        if (miUsr.getTxtCorreoElectronico2() != null) {
            strcomentario += "<span>Correo Alternativo: " + miUsr.getTxtCorreoElectronico2()+"</span><br/> ";
        }
        strcomentario += "<br/><span>Se solicita verificar los datos, si hubiera alg&uacute;n error comunicar a el &aacute;rea correspondiente.</span><br/>";
        
        strcomentario += "<br/><br/><span>Nota:  Este es un mensaje informativo enviado de forma autom&aacute;tica.</span><br/>";
        strcomentario += "<span>Agradecemos no responder a esta direcci&oacute;n de correo</span><br/>";
        
        RequestContext context = RequestContext.getCurrentInstance();
        mensaje = "Su pregunta secreta se ha actualizado correctamente";
        context.execute("wCambioPreguntaSecreta.hide()");
        context.execute("wCambioPreguntaSecretaOK.show()");
        SRespuestaSecreta = "";
        if (miUsr.getTxtCorreoElectronico1() != null) {
            enviaMail(miUsr.getTxtCorreoElectronico1(), "3", strcomentario);
        }
        if (miUsr.getTxtCorreoElectronico2() != null) {
            enviaMail(miUsr.getTxtCorreoElectronico2(), "3", strcomentario);
        }
        setBean(bean);
    }

    public void enviaContactoAdmin() throws Exception {
        RequestContext context = RequestContext.getCurrentInstance();
        Usuario usuario = (Usuario) getBeanBusqueda();
        if (usuario.getCodUsuario() == null) {
            setMessageError(new Exception("Por favor ingresa tu codigo de usuario"));
            return;
        }
        if (usuario.getCodUsuario().trim().equals("")) {
            setMessageError(new Exception("Por favor ingresa tu codigo de usuario"));
            return;
        }
        Usuario user = null;
        user = (Usuario) getService().findByCode(Usuario.class, usuario.getCodUsuario().trim());
        if (user == null) {
            setMessageError(new Exception("Usuario no registrado"));
            setBeanBusqueda(new Usuario());
        } else {
            FacesContext facesContext = FacesContext.getCurrentInstance();
            HttpSession session = (HttpSession) facesContext.getExternalContext().getSession(true);
            GregorianCalendar gcal = (GregorianCalendar) GregorianCalendar.getInstance();
            gcal.setTime(new Date());
            ControlAcceso envioLog = new ControlAcceso();
            envioLog.setNidUsuario(user);
            envioLog.setCodZonal(user.getCodZonal());
            envioLog.setTipOperacion(Constante.TIPO_OPERACION_CONTACTO_ADMIN);
            envioLog.setTxtSessionid(session.getId());
            envioLog.setNidModulo((Modulo) getService().findById(Modulo.class, Constante.NID_MODULO_SSA));
            envioLog.setFecRegistro(gcal.getTime());
            envioLog.setFlgAcceso(Constante.INTENTO_VALIDO);
            envioLog.setIp(obtenerDireccionIP());
            getService().save(envioLog);
            
            setBeanBusqueda(user);
            int numAleatorio = (int)(Math.random()*(999-100+1)+100);
            String firsLetterApeMat = user.getTxtApellidoMaterno().charAt(0)+"";
            String firsLetterApePat = user.getTxtApellidoPaterno().charAt(0)+"";
            String firsLetterNombre = user.getTxtNombres().charAt(0)+"";
            String strcomentario = "<span>Se remite el  c&oacute;digo de usuario  y su contrase&ntilde;a temporal.</span><br/>"
                        + "<span>La  primera vez que ingrese con esta cuenta, el sistema le pedir&aacute; de manera obligatoria el cambio de la contrase&ntilde;a temporal a su nueva clave.</span><br/><br/>"
                        + "<span>C&oacute;digo de Usuario: " + user.getCodUsuario()+"</span><br/>"
                        + "<span>Contrase&ntilde;a Temporal: " + retornaPasswordTemporal(user.getCodUsuario(),firsLetterApeMat,firsLetterApePat,firsLetterNombre,"0",numAleatorio)+"</span><br/><br/>";
            if (user.getTxtCorreoElectronico1() != null) {
                strcomentario += "<span>Correo Principal: " + user.getTxtCorreoElectronico1()+"</span><br/>";
            }
            if (user.getTxtCorreoElectronico2() != null) {
                strcomentario += "<span>Correo Alternativo: " + user.getTxtCorreoElectronico2()+"</span><br/>";
            }
            strcomentario += "<br/><span>Se solicita verificar los datos, si hubiera alg&uacute;n error comunicar a el &aacute;rea correspondiente.</span><br/>";
            strcomentario += "<br/><br/><span>Nota:  Este es un mensaje informativo enviado de forma autom&aacute;tica.</span><br/>";
            strcomentario += "<span>Agradecemos no responder a esta direcci&oacute;n de correo</span><br/>";
            
            Object bean = getBean();
            ControlAcceso control = ((ControlAcceso) getSpringBean(Constante.SESSION_ACCESO));
            user.setFlgCambioClave(Constante.ESTADO_ACTIVO);
            user.setTxtClave(retornaPasswordTemporal(user.getCodUsuario(),firsLetterApeMat,firsLetterApePat,firsLetterNombre,"1",numAleatorio));
            user.setNIdCtrlAccesoWeb(control.getId());
            
            setBean(user);
            super.beforeUpdate(null);
            super.doUpdate(null);
            log.info("End of Transaction: 'Update'");
            //getService().save(user);
            mensaje = "Su mensaje ha sido enviado al Administrador. En unos minutos "
                    + "recibirá su contraseña temporal, la que sera enviada a "
                    + "el(los) correo(s) registrado(s) en nuestra base de datos";
            context.execute("wContactoAdmin.hide()");
            context.execute("wContactoAdminOK.show()");
            if (user.getTxtCorreoElectronico1() != null) {
                enviaMail(user.getTxtCorreoElectronico1(), "1", strcomentario);
            }
            if (user.getTxtCorreoElectronico2() != null) {
                enviaMail(user.getTxtCorreoElectronico2(), "1", strcomentario);
            }
            setBean(bean);
        }
    }

    public void enviaMail(String strmailpara, String tipo, String strcomentario) {
        try {
            String strmail = Utilitarios.getContextUrl("1");
            String struser = Utilitarios.getContextUrl("2");
            String strpass = Utilitarios.getContextUrl("3");
            String strmailde = Utilitarios.getContextUrl("4");

            Properties props = new Properties();
            props.setProperty("mail.smtp.host", strmail);
            //props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", struser);
            props.setProperty("mail.smtp.auth", "false");

            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress(strmailde));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress(strmailpara));
            if(tipo.equals("1")){
                message.setSubject("Notificación del sistema de seguridad de FONCODES - Contraseña Temporal");
            }else if(tipo.equals("2")){
                message.setSubject("Notificación del sistema de seguridad de FONCODES - Cambio de Contraseña");
            }else if(tipo.equals("3")){
                message.setSubject("Notificación del sistema de seguridad de FONCODES - Actualización de Pregunta Secreta");
            }

            message.setContent(strcomentario, "text/html");
            Transport t = session.getTransport("smtp");
            t.connect(strmail, struser, strpass);
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        } catch (Exception e) {
            log.error("ERROR en enviaMail : " + e.getMessage());
            log.error("ERROR en enviaMail : " + e.getLocalizedMessage());
            log.error("ERROR en enviaMail : " + e);
        }
    }
    
    public String getNewPassword() {
        return newPassword;
    }

    public void setNewPassword(String newPassword) {
        this.newPassword = newPassword;
    }

    public String getVerifyPassword() {
        return verifyPassword;
    }

    public void setVerifyPassword(String verifyPassword) {
        this.verifyPassword = verifyPassword;
    }

    public void setIntento(int intento) {
        this.intento = intento;
    }

    public int getIntento() {
        return intento;
    }

    public boolean isbContactoAdmin() {
        return bContactoAdmin;
    }

    public void setbContactoAdmin(boolean bContactoAdmin) {
        this.bContactoAdmin = bContactoAdmin;
    }

    public String getSTerritorial() {
        return sTerritorial;
    }

    public void setSTerritorial(String sTerritorial) {
        this.sTerritorial = sTerritorial;
    }

    public Usuario getSelectedUsuario() {
        return selectedUsuario;
    }

    public void setSelectedUsuario(Usuario selectedUsuario) {
        this.selectedUsuario = selectedUsuario;
    }

    public List<Usuario> getLstUsuarios() {
        return lstUsuarios;
    }

    public void setLstUsuarios(List<Usuario> lstUsuarios) {
        this.lstUsuarios = lstUsuarios;
    }

    public UsuarioService getUsuarioService() {
        return usuarioService;
    }

    public void setUsuarioService(UsuarioService usuarioService) {
        this.usuarioService = usuarioService;
    }

    public HashMap<String, List<Accion>> getMenuBar() {
        return menuBar;
    }

    public void setMenuBar(HashMap<String, List<Accion>> menuBar) {
        this.menuBar = menuBar;
    }

    public boolean isBMuestraBloqueo() {
        return BMuestraBloqueo;
    }

    public void setBMuestraBloqueo(boolean BMuestraBloqueo) {
        this.BMuestraBloqueo = BMuestraBloqueo;
    }

    public boolean isBMuestraCaptcha() {
        return BMuestraCaptcha;
    }

    public void setBMuestraCaptcha(boolean BMuestraCaptcha) {
        this.BMuestraCaptcha = BMuestraCaptcha;
    }

    public boolean isRegistraAcesso() {
        return registraAcesso;
    }

    public void setRegistraAcesso(boolean registraAcesso) {
        this.registraAcesso = registraAcesso;
    }

    public String getMensaje() {
        return mensaje;
    }

    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }

    public String getSRespuestaSecreta() {
        return SRespuestaSecreta;
    }

    public void setSRespuestaSecreta(String SRespuestaSecreta) {
        this.SRespuestaSecreta = SRespuestaSecreta;
    }

    public List<General> getPreguntas() {
        return preguntas;
    }

    public void setPreguntas(List<General> preguntas) {
        this.preguntas = preguntas;
    }

    public String getSPreguntaSecreta() {
        return SPreguntaSecreta;
    }

    public void setSPreguntaSecreta(String SPreguntaSecreta) {
        this.SPreguntaSecreta = SPreguntaSecreta;
    }

    public boolean isBOlvidasteClave() {
        return BOlvidasteClave;
    }

    public void setBOlvidasteClave(boolean BOlvidasteClave) {
        this.BOlvidasteClave = BOlvidasteClave;
    }

    public Date getDFechaIdentidad() {
        return DFechaIdentidad;
    }

    public void setDFechaIdentidad(Date DFechaIdentidad) {
        this.DFechaIdentidad = DFechaIdentidad;
    }

    public String getSDniIdentidad() {
        return SDniIdentidad;
    }

    public void setSDniIdentidad(String SDniIdentidad) {
        this.SDniIdentidad = SDniIdentidad;
    }

    public String getSObsContactoAdmin() {
        return SObsContactoAdmin;
    }

    public void setSObsContactoAdmin(String SObsContactoAdmin) {
        this.SObsContactoAdmin = SObsContactoAdmin;
    }

    public List<String> getOpciones() {
        return Opciones;
    }

    public void setOpciones(List<String> Opciones) {
        this.Opciones = Opciones;
    }

    public boolean isLogueado() {
        return logueado;
    }

    public void setLogueado(boolean logueado) {
        this.logueado = logueado;
    }

    public String getSTextoCaptcha() {
        return STextoCaptcha;
    }

    public void setSTextoCaptcha(String STextoCaptcha) {
        this.STextoCaptcha = STextoCaptcha;
    }

    public boolean isBMuestraFecNac() {
        return BMuestraFecNac;
    }

    public void setBMuestraFecNac(boolean BMuestraFecNac) {
        this.BMuestraFecNac = BMuestraFecNac;
    }

    public boolean isBObligaPregunta() {
        return BObligaPregunta;
    }

    public void setBObligaPregunta(boolean BObligaPregunta) {
        this.BObligaPregunta = BObligaPregunta;
    }
    
    public String retornaPasswordTemporal(String codUsuario, String firsLetterApeMat, String firsLetterApePat, String firsLetterNombre, String tipo, Integer numAleatorio) throws ServiceException {
        String codUsuarioSinArroba = codUsuario;
        if(codUsuarioSinArroba.lastIndexOf(Constante.CARACTER_USUARIO_DOMINIO) > -1){
            codUsuarioSinArroba = codUsuarioSinArroba.replace(Constante.CARACTER_USUARIO_DOMINIO+"", "");
        }
        String enc_clave = codUsuarioSinArroba + firsLetterApeMat + firsLetterApePat + firsLetterNombre + numAleatorio;
        log.info("Clave DesEncriptada: " + enc_clave);
        if(tipo.equals("1")){
            enc_clave = getUsuarioService().retornaClaveEncriptada(enc_clave, codUsuario);
            log.info("Clave Encriptada: " + enc_clave);
        }
        return enc_clave;
    }
}